1.1.1 空白和注释#

1. 遵守一些规定会让C语言代码变得更加容易阅读和修改
2. 注释告诉读者程序能做些什么
3. 使用#if和#endif预处理有效地将代码从程序中去除

1
#if 0       //条件(真执行，假不执行)
2
    statements
3
#endif

1.1.2 预处理指令#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#define MAX_COLS 20
5
#define MAX_INPUT 1000

| 这五行被称为预处理指令，因为它们是由预处理器解释的。

1
int read_column_numbers(int columns[], int max);
2
void rearrange(char *output, char const *input,
3
                int n_columns, int const columns[]);

| 这些声明被称为函数原型(function prototype)。它告诉编译器这些以后将在源文件中定义的函数的特征。

1.1.3 main函数#

每个C程序都必须有一个main函数，因为它是程序执行的起点。

n_columns = read_column_numbers(columns,MAX_COLS);

这条语句调用函数read_column_numbers。数组columns和MAX_COLS代表的常量20作为参数传递给这个函数。在C语言中，数组参数是以 引用(reference) 传递的，也就是传址调用，而标量和常量则是按 值(value) 传递的。

1.1.4 关于scanf的格式代码#

常用的scanf格式代码除了%c,%s以外在输入值前的空白都会被省略。所以在使用scanf函数中的格式代码%c,%s输入时不能在输入值前有空格、换行和tab

基本概念

2.1 环境#

在ANSI C的任何一种实现中存在两种不同的环境
一种是翻译环境(translation environment)，在这个环境源代码被转换为可执行的机器指令。
一种是执行环境(execution environment)，用于实际执行代码

2.1.1 翻译#

翻译过程：编辑源文件->对源文件进行编译->对编译好的目标文件和链接器捆绑到一起->形成可执行程序
编译过程： 预处理器(preprocessor) 处理-> 源代码解析(parse) 处理->产生目标代码( 优化器(optimizer) 会对目标代码进一步处理)

2.1.2 执行#

程序必须载入到内存中(具有操作系统由操作系统执行)，无操作系统时必须手动载入

在 C 语言的翻译过程中，通常的顺序是：

预处理（Preprocessing）： 这一步会处理所有的宏定义（#define）、头文件包含（#include）以及条件编译（#if）等指令。预处理器生成一个扩展后的 C 代码，这个阶段的产物是一个没有预处理指令的纯 C 源代码。

编译（Compilation）： 在这一阶段，编译器将预处理后的 C 代码转换成汇编语言代码。编译器主要做语法分析、语义分析、优化等工作。最终生成的是与特定平台相关的汇编代码文件（通常以 .s 为后缀）。

汇编（Assembly）： 汇编器将编译生成的汇编代码转换成机器码，生成目标文件（通常以 .o 或 .obj 为后缀）。目标文件包含机器指令，但没有完整的可执行程序所需的所有内容。

链接（Linking）： 链接器将多个目标文件和库文件合并，解决符号（如函数和变量的地址）之间的依赖关系，最终生成可执行文件（如 .exe 或没有后缀的文件）。如果有外部库函数或其他目标文件，链接器会将它们合并成一个完整的可执行程序。

总结起来，C 语言的翻译过程是：

预处理

编译（生成汇编代码）

汇编（生成目标文件）

链接（生成可执行文件）

所以，是先编译再汇编，然后通过汇编生成目标文件，最后由链接器生成可执行程序。

2.2 词法规则#

词法规则就是标记(token)

2.2.1 字符#

使用转义序列(escape sequence)和字符转义(character escape) 对上下文环境中特定字符表示

常见的有\? \" \' \\和\a \b \f \n \r \t \v

用于表示八进制和十六进制的转义符有 \ddd \xddd

2.2.2 注释#

注意跨越多行的注释

2.2.3 自由形式的源代码#

c格式相对自由，相邻的标记之间有一个或多个空白

2.2.4 标识符(identifier)#

标识符就是变量、函数、类型等的名字，由大小写字母、数字和下划线组成，不能以数字开头。有32个关键字

2.2.5 程序的形式#

一个C程序的源文件应该包含一组相关的函数，这是C程序较为合理的组织形式。

2.3 程序风格#

C 语言程序风格（Coding Style）是指在编写 C 语言代码时，为了提高可读性、可维护性和可扩展性而遵循的一些规范和约定。良好的程序风格可以让代码更加清晰，减少错误，并便于团队协作。以下是一些常见的 C 语言编程风格规范：

1
int main(){
2
    if(condition){
3
        // statements
4
    }
5
}

1
if(condition){
2
    // 代码块
3
} else {
4
    // 代码块
5
}

2.4 总结#

• 一个C程序的代码保存在一个或多个源文件中，但一个函数只能完整地出现在同一个源文件中。把相关函数放在同一个文件内是一种好策略。

数据

3.1 基本数据类型#

• 在C语言中，只有四种基本数据类型：整形、浮点型、指针和聚合类型(数组和结构)

字符型是整型的一种

3.1.1 整型家族#

分为字符型、短整型、整型和长整型，且分为有符号(signed)和无符号(unsigned)

• 长整型至少应该和整型一样长，整型至少应该和短整型一样长。
• 如果显示地把变量声明为signed或unsigned可以提高这类程序的可移植性。

1.整型字面值

字面值(literal) 这个术语是字面值常量的缩写————这是一种实体，指定了自身的值并且不允许发生改变。所以ANSI C允许 命名常量const

在整数值后面添加l或L将整数解释为长整型值、u或U将数值指定为unsigned整型值。ul和UL就是这两个的结合

对于多字节字符如果一个多字节字符常量的前面有一个L那么它就是**宽字符常量(wide character literal)**如： L'X' L'e^'

不管采用何种字符集，使用字符常量所产生的总是正确的值，所以字符常量能提高程序的可移植性

2.枚举类型

枚举(enumerated)类型就是指它的值为符号常量而不是字面值的类型

1
enum Jar_Type { CUP, PINT, QUART, HALF_GALLON, GALLON}; //声明了一个enum类型称为Jar_Type
2
enum { CUP, PINT, QUART, HALF_GALLON, GALLON} milk_jug,gas_can; // 匿名枚举类型并直接定义枚举类型变量 milk_jug,gas_can
3
enum Jar_Type { CUP = 8, PINT = 10, QUART = 11, HALF_GALLON, GALLON};
4
// 根据enum赋值规律，HALF_GALLON的值为12，GALLON为13

3.1.2 浮点类型#

浮点数字面值在缺省情况下都是double类型的，后跟L为long double，跟F为float

3.1.3 指针#

1. 指针常量

指针常量只能通过已分配的内存的元素得知。
因此，把指针常量表达为数值字面值的形式几乎没有用处。

2. 字符串常量

可以把字符串常量赋值给一个指向字符类型的数组char*
不能把字符串常量赋值给一个字符数组char[]

3.2 基本声明#

变量声明的基本形式是：说明符(一个或多个) 声明表达式列表

int* a,b,c和int *a,*b,*c是在声明指针时非常容易搞混的两个概念，为避免概念上的错误建议将*号写在靠近变量名那一侧

3.2.4 隐式声明#

一条语句实际上是一个声明时，如果它缺少类型名，编译器会假定它为整型

依赖隐式声明不是一个好主意

3.3 typedef#

typedef 为数据类型定义新名字

1
char *ptr_to_char; 是一个指向字符的指针
2
在添加关键字typedef后
3
typedef char* ptr_to_char;
4
这个声明把标识符ptr_to_char 作为指向字符的指针类型的新名字
5
ptr_to_char a; 声明a是一个指向字符的指针

• 在定义函数指针或指向数组的指针时使用typedef更为合适。

3.4 常量#

对于普通的数据类型来说 int const a; 和 const int a;没有什么区别，因为对于整型只有值会变成常量

但是对于指针来说有两种东西可能成为常量：‘指针变量’和‘指针所指向的实体’

1
int *pi; 是一个普通的指向整型的指针
2
而
3
int const *pci;
4
则是一个指向整型常量的指针，可以修改指针的值但不能修改它所指向的值
5
相比之下
6
int *const pci;
7
则是一个指向整型的常量指针。此时指针是常量，它的值无法修改，但是可以修改它所指向的整型的值。

在 C 语言中，“指向整型的常量指针”和“指向常量整型的指针”是两个非常常见的概念，它们在语法和使用上有所不同。下面我会分别讲解这两者的含义：

1. 指向整型的常量指针（const intptr 或 int const ptr） 这种指针类型表示 指针本身是常量，即指针的值（即它指向的地址）不可修改，但是指针指向的 整型数据 是可以修改的。

1
int a = 10;
2
int b = 20;
3
const int *ptr = &a; // 或者int const *ptr = &a;
4
*ptr = 15; // OK，指向的值可以修改
5
ptr = &b; // 错误，不能修改指针的地址(指针本身是常量)

2. 指向常量整型的指针（int* const ptr） 这种指针类型表示 指针指向的数据是常量，即指针指向的 整型数据不可修改，但是指针本身可以修改，使其指向不同的地址。

1
int a = 10;
2
int b = 20;
3
int* const ptr = &a;
4
*ptr = 15; // 错误，不能修改指向的数据
5
ptr = &b; // 正确，指针本身可以修改

3. 两者结合使用（const intconst ptr 或 int const const ptr） 如果同时声明指针是常量且指向的数据是常量，那么就变成了“常量指针指向常量数据”。

1
int a = 10;
2
const int* const ptr = &a;
3

4
*ptr = 15;  // 错误！不能修改指向的数据
5
ptr = &b;   // 错误！不能修改指针本身

3.5 作用域(scope)#

3.5.1 代码块作用域#

特殊情况类似内层代码和外层代码拥有同一个标识符名字内层的标识符会隐藏外层的标识符

应该避免在嵌套的代码块中出现相同的变量名

3.6 链接属性#

链接属性一共有三种：external(外部)、internal(内部)和none(无)

1. 外部链接（External Linkage） 具有外部链接的符号可以在整个程序的多个翻译单元中访问。它意味着符号可以在一个文件中声明，并在其他文件中定义或使用。

全局变量：如果在一个文件中声明了全局变量，并在其他文件中引用该变量，它会具有外部链接。

外部函数：同样地，外部函数可以在一个文件中定义，并在其他文件中调用。

示例：

1
#include <stdio.h>
2

3
int global_var = 10; // 外部链接
4
void func()
5
{
6
    printf("Hello World!\n");
7
}
8

9
// file2.c
10
extern int global_var; //声明具有外部链接的变量
11
extern void func(); // 声明外部函数
12

13
int main()
14
{
15
    func();
16
    printf("Global variable: %d\n",global_var);
17
    return 0;
18
}

• global_var和func()都具有外部链接，可以在file2.c中访问

2. 内部链接（Internal Linkage） 具有内部链接的符号只能在同一翻译单元（即同一源文件及其包含的头文件）中访问。它们不能跨文件使用。

static 关键字：使用 static 关键字声明的变量或函数具有内部链接。它意味着该符号的作用域仅限于当前源文件。

示例：

1
#include <stdio.h>
2
static int internal_var = 10; // 内部链接，只能在file1.c中使用
3
static void internal_func(){
4
    // 内部链接，只能在file1.c中调用
5
    printf("This is an internal function\n");
6
}
7

8
int main()
9
{
10
    internal_func();
11
    printf("Internal variable: %d\n",internal_var);
12
    return 0;
13
}
14

15
// file2.c
16
extern void internal_func(); // 无法调用，因为internal_func在file1.c中是静态的
17
extern int internal_var; // 无法访问，因为internal_var是静态的

• internal_var和internal_func()只能在file1.c中使用，其他文件无法访问它们

3. 无链接（No Linkage） 没有链接的符号意味着它们在某个特定范围内是唯一的，通常这些符号仅限于局部作用域。局部变量和函数的参数一般都是无链接的。

局部变量：它们的作用域仅限于函数内部，其他函数无法访问。

示例：

1
void func() {
2
    int local_var = 10;  // 无链接，仅在func内部有效
3
    printf("Local variable: %d\n", local_var);
4
}
5

6
int main() {
7
    func();
8
    // 下面的代码会导致错误，因为local_var在main函数外不可见
9
    // printf("Local variable in func: %d\n", local_var);
10
    return 0;
11
}

• local_var只能在func()内部使用，其他地方无法访问

总结：

外部链接（External Linkage）：符号可以在多个翻译单元（源文件）之间共享。通过 extern 关键字进行声明。

内部链接（Internal Linkage）：符号仅在当前源文件内有效，不能跨文件访问。通过 static 关键字来定义。

无链接（No Linkage）：符号仅在局部作用域内有效，通常用于函数参数和局部变量。

1
static int i;
2
int func()
3
{
4
    int j;
5
    extern int k;
6
    extern int i;
7
}

• 当extern关键字用于源文件中一个标识符的第一次声明时，它指定该标识符具有external链接属性。但是如上面所示在int i一开始声明了static后并不会在func内部修改extern int i为external链接属性

3.7 存储类型#

有三个地方可以用于存储变量：普通内存、运行时堆栈、硬件寄存器。

• 凡是在任何代码块之外的声明的变量总是存储于静态内存中，也就是不属于堆栈的内存，这类变量称为静态(static)变量
• 在代码块内部声明的变量的缺省存储类型是自动的(automatic)，也就是说它存储于堆栈中，称为自动(auto)变量
• 对于在代码块内部声明的变量如果给它加上关键字static，可以使它的存储类型从自动变为静态。函数的形参不能声明为静态，因为实参总是在堆栈中传递给函数
• 关键字register可以用于自动变量的声明，声明变量应该存储于机器的硬件寄存器而不是内存

初始化

• (P44)自动变量初始化和静态变量初始化存在一个重要的差别。

在静态变量初始化中我们可以把可执行程序想要初始化的值放在当程序执行时变量将会使用的位置。

自动变量的初始化需要更多的开销,因为当程序链接时还无法判断自动变量的存储位置，事实上函数的局部变量在函数的每次调用时都可能占据不同的位置

自动变量的初始化较之赋值语句效率并无提高，除了声明为const的变量之外这两者只有风格之差，并无效率之别。

优点是由于初始化在运行时执行因此可以用任何表达式作为初始化值，例如：

1
int
2
func(int a)
3
{
4
    int b = a + 2;
5
}

最后一个后果是除非对自动变量进行显式的初始化，否则当自动变量创建时，它们的值总是垃圾。

3.8 static关键字#

当用于函数定义时，或者用于代码块之外的变量声明时，static关键字用于修改标识符的连接属性(从external 改为 internal)，但标识符的存储类型和作用域不受影响。

用于代码块内部的变量声明时static关键字用于修改变量的存储类型，从自动变量改为静态变量，但变量的链接属性和作用域不受影响。

3.10 总结#

• 具有external链接属性的实体总是具有静态存储类型
• 如果一个变量声明于代码块内部，在它前面添加extern关键字将使它所引用的是全局变量而不是局部变量。

语句

4.1 空语句#

;空语句本身不执行任何任务

4.2 表达式语句#

只要在表达式后面加上一个分号，就可以把表达式转变为语句

1
x = y + 3;
2
ch = getchar();

是表达式语句

类似于printf函数这类没有返回值的函数在标准输出中输出内容的作用称为副作用(side effect)

4.3 代码块#

• 一对花括号之内的可选的声明和语句列表

1
{
2
    declarations
3
    statements
4
}

4.4 if语句#

• C 并不具备布尔类型而是用整型来替代
• else语句从属于最靠近它的不完整的if语句

4.5 while语句#

…

4.9 goto语句#

goto 语句标签;

1. 资源清理和错误处理(C中没有异常机制)

1
#include <stdio.h>
2
#include <stdlib.h>
3

4
int func()
5
{
6
    int *p = malloc(100);
7
    if(!p) goto fail;
8

9
    FILE *fp = fopen("file.txt","r");
10
    if(!fp) goto cleanup;
11

12
    // 正常执行逻辑
13
    fclose(fp);
14
    free(p);
15
    return 0;
16
cleanup:
17
    free(p);
18
fail:
19
    return -1;
20
}

2. 从多层嵌套中快速跳出

1
for (int i = 0; i < 5; ++i) {
2
    for (int j = 0; j < 5; ++j) {
3
        if (i + j == 6) goto done;
4
    }
5
}
6
done:
7
printf("Exited nested loops\n");

goto 是 C 的原始控制流工具，能跳到代码中的任意标签；

不推荐滥用，但在特定情况下（如资源清理、退出多层嵌套）是非常有效的；

如果你在写可读性强、模块化的现代代码，能不用就尽量不用；

如果你在写驱动、内核、嵌入式或老式 C 代码，合理使用是完全 OK 的。

4.10 总结#

操作符和表达式

5.1 运算符#

• 算数运算符(右结合)

+ - * / %除了%其他的操作符都适用于整型和浮点型

• 移位操作符(右结合)

<< >>左移和右移操作符 左移右边多出来填充0，右移左边多出来填充0或1(具体看是逻辑运算还是算数运算（符号位1填1，符号位0填0）)

a << -5左移-5位是什么意思其实不重要，结果是由编译器决定的，且其结果无意义，不能在程序中出现这种情况

• 位操作符(右结合)

& | ^分别执行与或和异或操作

或操作符与左移操作符结合：

1
int value = 0b00001010;
2
int bit_number = 1;
3
value = value | (1 << bit_number);
4
// 即 value = 0b00001010 | ob00000010 = 0b00001010 （值没有发生改变）
5
bit_number = 2;
6
value = value | (1 << bit_number);
7
// 即：value = 0b00001010 | 0b00000100 = 0b00001110 （值变成 14）

• 赋值符和复合赋值符(左结合)

可以用复合赋值符改写上面的操作

1
value |= 1 << bit_number;
2
value &= 1 << bit_number;

• 单目运算符(左结合)

~操作符对二进制数进行求补操作，操作数原为1则为0，原为 0则为1

&操作符为取址符

*间接访问操作符

sizeof()判断操作数类型长度

指针

6.1 内存和地址#

我们对两件事情感兴趣：

• 内存中的每个位置由一个独一无二的地址标识：
• 内存中的每个位置都包含一个值：

名字与内存位置之间的关联并不是硬件提供的，而是由编译器为我们实现的。

硬件仍然通过地址访问内存位置。

6.2 值和类型#

• 不能简单地通过检查一个值的位来判断它的类型。

1
int a = 112;
2
float b = 3.14;
3
int *c = &a;
4
int *d = &b;

在这上面变量a被解释为整型值，但b存储的为浮点值，在内存中却可能被解释为整型值，变成一个非常大的整型值。由于解释方法不同有可能被解释为整数1078523331。

大部分情况编译器会帮助我们避免这些错误。当程序访问时编译器就会产生浮点型指令。

6.3 指针变量的内容#

上面的变量c和d为指针，指针初始化是用&操作符完成的，该操作数用于产生操作数的内存地址。

区分变量c、d的地址和c、d存储的内容是非常重要的。c、d存储的内容为a、b的地址，c、d的地址为变量自身在内存中的地址。

6.4 间接访问操作符#

*操作符执行间接访问(idirection) 或 解引用(dereferencing the pointer)。

6.5 未初始化和非法的指针#

1
int *a;
2
*a = 12;

a指向了哪里，我们声明了这个变量但是未对他进行初始化，所以没有办法预测12这个值将存储于什么地方。

无论是哪种情况声明一个指向整型的指针都不会“创建”用于存储整型值的内存空间。

所以程序执行这个赋值操作，有可能：

1. a的初始值会是个非法地址，这样赋值语句将会出错，从而终止程序。在UNIX系统上这个错误被称为 “段违例”(segmentation violation) 或 内存错误(memory fault)。它提示程序试图访问一个并未分配给程序的内存空间。

2. 对于那些要求整数必须存储于特定边界的机器而言，如果这种类型的数据在内存中的存储地址处于错误的边界上，那么对这个地址进行访问时将会产生一个错误。这个错误在UNIX系统中被称为 总线错误(bus error) 。

3. 一种更为严重的情况是，这个指针偶尔可能包含了一个合法的地址。接下来的事情很简单：位于那个位置的值被修改！

6.6 NULL指针#

要使一个指针变量为NULL可以给它赋一个零值。

p96 NULL指针用法

• 对一个NULL指针解引用是非法的，因为NULL指针没有指向任何东西。

6.7 指针、间接访问和左值#

1
int a;
2
int *d = &a;
3

4
*d = 10 - *d;       // 1.正确
5
d = 10 - *d;        // 2.错误

第一条语句包含了两个间接操作。右边的间接访问作为右值使用，所以它的值d所指向的位置所存储的值(a的值)。左边的间接访问作为左值使用，所以d所指向的位置a把赋值符右边的表达式的计算结果作为它的新值。

第二条语句是非法的，因为它表示把一个整型变量(10 - *d)存储于一个指针变量中，当实际使用的变量类型和应该使用的变量类型不一致时，编译器会发出警告。

6.8 指针、间接变量和变量#

*&a = 25 和 a = 25的效力是相同的，但是它涉及更多的操作，且这种写法会使得代码可读性更差。

6.9 指针常量#

如果变量a存储于位置100

*100 = 25;看上去像是把25赋值给a，但是这是错的！因为字面值100的类型是整型而不是指针类型表达式，如果想把25存储于位置100必须使用强制类型转换。

*(int *)100 = 25;这种写法合法，但是需要使用这种技巧的地方几乎碰不到！因为在编译器执行前无法确定变量会存储在内存的什么位置。

6.10 指针的指针#

1
int a = 12;
2
int *b = &a;
3
int **c = &b;

*操作符具有从右向左的结合性，表达式**c的类型是int，它是指针的指针。*c访问c所指向的位置，我们知道这是变量b。

6.11 指针表达式#

符号优先级：() > ++ > * > -

• 分析几个重要的指针表达式

1
char ch = 'a';
2
char * cp = &ch;

1. *cp + 1
2. *(cp + 1)
3. ++cp
4. cp++
5. *++cp
6. *cp++
7. ++*cp
8. (*cp)++
9. ++*++cp
10. ++*cp++

• *cp + 1 先执行间接访问操作得到它的值，后取得这个值的副本执行与1相加的操作。表达式最终结果为字符’b’。该表达式最终结果的存储位置并未清晰定义，所以不是一个合法左值。
• *(cp + 1) 指针加法运算的结果是一个右值，之后对这个右值进行间接访问操作后可以将其作为左值使用，尽管cp + 1本身并不是左值。

间接访问操作符是少数几个其结果为左值的操作符之一。

• ++cp和cp++唯一区别是这两个表达式的返回值一个是cp + 1的副本，一个是cp的副本。且这两个表达式都不是合法的左值。
• *cp++和*++cp与不加间接访问操作的上面两个式子不同。右值为ch + 1 或 ch那个内存地址的值，左值为那个位置本身(作为变量使用)。
• ++*cp与上式不同，由于*和++操作符都是左结合性，首先执行间接访问操作，然后cp所指向的位置的值加一，表达式结果是这个增值后的值的一个副本。
• (*cp)++是原本cp增值前的原先值，和ch++操作相同
• ++*++cp先执行*++cp后执行++*++cp，结果为*++cp自增后的拷贝。
• ++*cp++和上式的唯一区别是*++cp和*cp++的区别。

6.12 实例#

程序6.1：字符串的长度

1
#include <stdlib.h>
2
size_t
3
strlen(char *string)
4
{
5
    int     length = 0;
6
    while(*string++ != '\0')
7
        length += 1;
8
    return length;
9
}

程序6.2：在一组字符串中查找指定的字符(版本1)

1
#include <stdio.h>
2
#define     TRUE    1
3
#define     FALSE   0
4

5
int
6
find_char(char **strings, char value)
7
{
8
    char* string;
9
    // 未初始化的字符串类型
10

11
    // 对于列表中的每个字符串
12

13
    while( (string = *strings++) != NULL)
14
    {
15
        // 观察字符串中的每个字符
16
        while( *string != '\0')
17
        {
18
            if( *string++ == value)
19
                return TRUE;
20
        }
21
    }
22
    return FALSE;
23
}

程序6.3：在一组字符串中查找(版本2)

1
#include <stdio.h>
2
#include <assert.h>
3
#define TRUE 1
4
#define FALSE 0
5

6
int
7
find_char(char **strings, int value)
8
{
9
    assert(strings != NULL);
10
    while(*strings != NULL)
11
    {
12
        while(**strings != '\0')
13
        {
14
            if(*(*strings)++ == value)
15
                return TRUE;
16
        }
17
        strings++;
18
    }
19
    return FALSE;
20
}

6.13 指针运算#

• 对指针的操作不依赖于指针的类型

1
int arr[5] = {1,2,3,4,5};
2
int *a = &arr[0];
3
int *b = &arr[3];
4
// b - a = 3
5
// a - b = -3 ----> 指针可以进行反向运算并结果为负数

1
#define N_VALUES    5
2
float values[N_VALUES];
3
float *vp;
4
for(vp = &value[0]; vp < &values[N_VALUES];)
5
    *vp++ = 0;

1
for(vp = &values[N_VALUES - 1]; vp >= &values[0];vp--)
2
    *vp = 0;

6.14 总结#

• 计算机内存中的每个位置都由一个地址标识。通常邻近的内存位置合成一组，这样就允许存储更大范围的值。指针的值表示的是内存地址的变量。

😠 函数#

1
类型
2
函数名( 形式参数 )
3
代码块
4

5
function_name()
6
{
7

8
}

1
int *
2
find_int(key, array, array_len)
3
int key;
4
int array[];
5
int array_len;
6
{}

1
#ifndef COUNTER_H
2
#define COUNTER_H
3

4
// Increment the counter by 1.
5
void increment_counter(void);
6

7
// Get the current value of the counter.
8
int get_counter(void);
9
#endif // COUNTER_H

1
#include "counter.h"
2
#include <stdio.h>
3
// This is a static variable. Its value is kept for the lifetime of the program,
4
// but it is only visible and accessible within this file (counter.c).
5
static int count = 0;
6

7
// This is a static function. It's a private helper and cannot be called
8
// from outside this file.
9
static void private_helper()
10
{
11
  printf("--- (Internal) The counter is now being updated... ---\n");
12
}
13

14
// Public API function. It calls the private helper function
15
void increment_counter()
16
{
17
  private_helper(); // This is allowed bacause private_helper is in the same file.
18
  count++;
19
}
20

21
// Public API function. It returns the value of the private variable.
22
int get_counter()
23
{
24
  return count;
25
}

1
#include <stdio.h>
2
#include "counter.h"
3

4
int main()
5
{
6
  printf("Initial counter value: %d\n",get_counter());
7

8
  // Call the public function to increment the counter.
9
  increment_counter();
10
  printf("Counter value after first increment: %d\n", get_counter());
11

12
  increment_counter();
13
  printf("Counter value after second increment: %d\n", get_counter());
14

15
  // COMPILE/LINK ERROR!
16
  // The linker will fail because private_helper() is not a public symbol.
17
  // private_helper();
18

19
  return 0;
20
}

1
factorial(n) =
2
├── n <= 0 : 1
3
└── n > 0 : n x factorial(n - 1)

1
long
2
factorial(int n)
3
{
4
  if (n <= 0)
5
    return 1;
6
  else
7
    return n * factorial(n - 1);
8
}

1
long
2
factorial(int n)
3
{
4
  int result = 1;
5
  while (n > 1)
6
  {
7
    result *= n;
8
    n -= 1;
9
  }
10

11
  return result;
12
}

1
Fibonacci(n) =
2
├── n <= 1 : 1
3
├── n = 2 : 1
4
├── n > 2 : Fibonacci(n - 1) +Fibonacci(n - 2)

1
long fibonacci(int n)
2
{
3
  if (n <= 2)
4
    return 1;
5

6
  return fibonacci(n - 1) + fibonacci(n - 2);
7
}

1
long fibonacci(int n)
2
{
3
  long result;
4
  long previous_result;
5
  long next_older_result;
6

7
  result = previout_result = 1;
8

9
  if (n <= 2)
10
    return 1;
11

12
  while (n > 2)
13
  {
14
    n -= 1;
15
    next_older_result = previous_result;
16
    previous_result = result;
17
    result = previous_result + next_older_result;
18
  }
19
}

1
float average(int n_values, int v1,int v2, int v3, int v4, int v5)
2
{
3
  float sum = v1;
4

5
  if ( n_values >= 2)
6
    sum += v2;
7
  if ( n_values >= 3 )
8
    sum += v3;
9
  if ( n_values >= 4 )
10
    sum += v4;
11
  if ( n_values >= 5 )
12
    sum += v5;
13

14
  return sum / n_values;
15
}

1
#include <stdarg.h>
2

3
float average(int n_values, ...) // 传递任意数量的未知数
4
{
5
  va_list var_arg;
6
  int count;
7
  float sum;
8

9
  // 准备访问可变参数
10
  va_start (var_arg, n_values);
11

12
  // 添加取自可变参数列表的值
13
  for (count = 0;count < n_values;count += 1)
14
    sum += va_arg(var_arg, int);
15

16
  // 完成处理可变参数
17
  va_end(var_arg);
18

19
  return sum / n_values;
20
}

🖐 数组#

1
int a;
2
int b[10];

1
array[subscript] == *(array + (subscript))

1
int array[10];
2
int *ap = array + 2;

1
int array[10],a;
2
for (a = 0;a < 10;a++)
3
  array[a] = 0;

1
int array[10],*ap;
2
for (ap = array;ap < array + 10;ap++)
3
  *ap = 0;

1
#define SIZE 50
2
int x[SIZE];
3
int y[SIZE];
4
int i;
5
int *p1,*p2;

1
void try1()
2
{
3
  for(i = 0; i < SIZE;i++)
4
    x[i] = y[i];
5
}

1
void try2()
2
{
3
    for( p1 = x, p2 = y; p1 - x < SIZE;)
4
      *p1++ = *p2++;
5
}

1
void try3()
2
{
3
  for( i = 0; p1 = x, p2 = y; i < SIZE; i++)
4
  {
5
    *p1++ = *p2++;
6
  }
7
}

1
void try4()
2
{
3
  register int *p1, *p2;
4
  register int i;
5

6
  for( i = 0;p1 = x, p2 = y;i < SIZE; i++)
7
    *p1++ = *p2++;
8
}

1
void try5()
2
{
3
  register int *p1, *p2;
4

5
  for( p1 = x, p2 = y;p1 < &x[SIZE])
6
  {
7
    *p1++ = *p2++;
8
  }
9
}

1
void strcpy(char *buffer, char const *string)
2
{
3
  while (*buffer++ = *string++ != '\0');
4
}

1
int   vector[10], *vp = vector;
2
int   matrix[3][10], *mp = matrix;

1
int *pi = &matrix[0][0];
2
int *pi = matrix[0];

1
void func2(int (*mat)[10]);
2
void func2(int mat[][10]);

1
int matrix[2][3] = {100,101,102,110,111,112};
2

3
int two_dim[3][5] = {
4
  {00,01,02,03,04},
5
  {00,01,02,03,04},
6
  {00,01,02,03,04}
7
};

1
char const *keyword[] = {
2
    "do",
3
    "for",
4
    "register",
5
    "return",
6
    "switch",
7
    "while",
8
    NULL
9
};
10
#define N_KEYWORD \
11
  (sizeof(keyword) / sizeof(keyword[0]))
12

13
# 判断参数是否与一个关键字列表中的任何单词匹配，并返回匹配的索引值。
14
# 如果未找到匹配函数返回-1
15
#include <string.h>
16

17
int lookup_keyword( char const* const desired_word,
18
              char const *keyword_table[], int const size)
19
{
20
  char const **kwp;
21

22
  // 对于表中的每个单词 ...
23
  // for (kwp = keyword_table; kwp < keyword_table + size; kwp++)
24
  // {
25
  //   if (strcmp(desired_word, *kwp) == 0)
26
  //       return kwp - keyword_table;
27
  // }
28
  for (kwp = keyword_table; kwp != NULL;kwp++)
29
  {
30
    if (strcmp(desired_word, *kwp) == 0)
31
      return kwp - keyword_table;
32
  }
33

34

35
  // 没有找到
36
  return -1;
37
}

💝 字符串、字符和字节#

• 字符串是一种重要的数据类型，但是C语言并没有显式的字符串数据类型，因为字符串以字符串常量的形式出现或者存储于字符数组中。
• 操作字符串变量时必须额外小心各种可能导致缓冲区溢出的操作。

1
strlen 原型
2
size_t strlen (char const *string);

1
if (strlen(x) >= strlen(y)) ...
2
if (strlen(x) - strlen(y) >= 0) ...

1
#include <stddef.h>
2

3
size_t
4
strlen(char const *string)
5
{
6
  int length;
7

8
  for (length = 0; *string++ != '\0';)
9
    length += 1;
10
  return length;
11
}

1
if (strlen(x) >= 10) ...
2
if (strlen(x) - 10 >= 0) ...

1
char *strcpy(char *dst, char const *src);

1
char *strcat( char *dst, char const *src);

1
strcpy( message, "Hello ");
2
strcat( message, customer_name );
3
strcpy( message, ", how are you?");

1
strcat(strcpy(dst,a),b);

1
strcpy(dst,a);
2
strcat(dst,b);

1
int strcmp(char const *s1, char const *s2);

1
if (strcmp(a,b)) // 用于布尔值测试是一种坏风格
2
if (strcmp(a,b) > 0) // 用于与零进行比较更好
3
else if (strcmp(a,b) < 0)
4
else

1
char *strncpy(char *dst, char const *src, size_t len);
2
char *strncat(char *dst, char const *src, size_t len);
3
char *strncmp(char const *s1, char const *s2, size_t len);

1
char buffer[BSIZE];
2
...
3
strncpy(buffer, name, BSIZE);
4
buffer[BSIZE - 1] = '\0';

1
char *strchr(char const *str, int ch);
2
char *strrchr(char const *str, int ch);

1
char string[20] = "Hello there, honey.";
2
char *ans;
3
ans = strchr(string, 'h');

1
char *strpbrk(char const *str, char const *group);

1
char string[20] = "Hello there, honey.";
2
char *ans;
3
ans = strchr(string, "aeiou");

1
char *strstr(char const *s1, char const *s2);

1
#include <string.h>
2

3
char*
4
my_strrstr(char const *s1, char const *s2)
5
{
6
  register char *last;
7
  register char *current;
8

9
  // 把指针初始化为我们已经找到的前一次匹配
10
  last = NULL;
11

12
  // 只在第二个字符串不为空的时候进行查找，如果s2为空返回NULL
13

14
  if (*s2 != '\0')
15
  {
16
    // 查找 s2 在 s1 中第一次出现的位置。
17
    current = strstr(s1,s2);
18
    while (current != NULL)
19
    {
20
      last = current;
21
      current = strstr(last + 1, s2);
22
    }
23
  }
24
  return last; // 返回指向我们找到的最后一次匹配的起始位置的指针。
25
}

1
#include <string.h>
2

3
char *
4
my_strrpbrk(char const *str, char const *group)
5
{
6
  register char *last;
7
  register char current;
8

9
  // 把指针初始化为我们已经找到的前一次匹配
10
  last = NULL;
11

12
  if (*s2 != '\0')
13
  {
14
    current = strpbrk(str, group);
15
    while (current != NULL)
16
    {
17
      last = current;
18
      current = strpbrk(last + 1, group);
19
    }
20
  }
21
  return last;
22
}

1
size_t strspn(char const *str, char const *group);
2
size_t strcspn(char const *str, char const *group);

1
#include <stdio.h>
2
#include <string.h>
3

4
int main() {
5
    const char *sentence = "Hello, world!";
6
    const char *charset_vowels = "aeiou";
7
    const char *charset_alpha = "abcdefghijklmnopqrstuvwxyz";
8

9
    size_t length1 = strspn(sentence, "Heo");
10
    printf("The length of the initial part of \"%s\" consisting of 'H', 'e', 'o' is: %zu\n", sentence, length1);
11
    // 输出: 2 (因为 'l' 不在 "Heo" 中)
12

13
    size_t length2 = strspn(sentence, charset_alpha);
14
    printf("The length of the initial part of \"%s\" consisting of letters is: %zu\n", sentence, length2);
15
    // 输出: 5 (因为 ' ' 不在字母表中)
16

17
    return 0;
18
}

1
char *strtok(char *str, char const *sep);

1
#include <stdio.h>
2
#include <string.h>
3

4
int main(void)
5
{
6
  char str[] = "apple,banana-orange";
7
  const char *delimiters = ",-";
8
  char *token;
9

10
  // 第一次调用， 传入字符串
11
  token = strtok(str,delimiters);
12
  printf("First token: %s\n", token);
13

14
  // 后续调用，传入NULL
15
  while(token != NULL)
16
  {
17
    token = strtok(NULL,delimiters);
18
    if (token != NULL){
19
      printf("Next token: %s\n",token);
20
    }
21
  }
22
  return 0;
23
}

1
char *stderror(int error_number);

1
#include <stdio.h>
2
#include <string.h>
3
#include <errno.h>
4
// 必须包含此头文件来使用 errno
5

6
int main(void)
7
{
8
  FILE *file;
9
  // 尝试打开一个不存在的文件
10
  file = fopen("non_existent_file.txt", "r");
11

12
  // 如果 fopen 失败
13
  if (file == NULL)
14
    printf("Error opening file: %s\n", strerror(errno));
15
  else
16
  {
17
    printf("File opened successfully.\n");
18
    fclose(file);
19
  }
20
  return 0;
21
}

1
int tolower(int ch);
2
int toupper(int ch);
3

4
if (ch >= 'A' && ch <= 'Z') 在ASCII字符集的机器上能够运行，但是其他字符集有可能会失败
5
if (isupper(ch))
6
就都能顺利运行

1
void *memcpy(void *dst, void const *src, size_t length);
2
void *memmove(void *dst, void const *src, size_t length);
3
void *memcmp(void const *a, void const *b, size_t length);
4
void *memchr(void const *a, int ch, size_t length);
5
void *memset(void *a, int ch, size_t length);